{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "51f79ac5-1e09-4933-9009-9ade92901b3c",
   "metadata": {},
   "source": [
    "Copyright (c) MONAI Consortium <br>\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\"); <br>\n",
    "you may not use this file except in compliance with the License. <br>\n",
    "You may obtain a copy of the License at <br>\n",
    "http://www.apache.org/licenses/LICENSE-2.0 <br>\n",
    "Unless required by applicable law or agreed to in writing, software <br>\n",
    "distributed under the License is distributed on an \"AS IS\" BASIS, <br>\n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>\n",
    "See the License for the specific language governing permissions and <br>\n",
    "limitations under the License. <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95c08725",
   "metadata": {},
   "source": [
    "# Super-resolution using Stable Diffusion v2 Upscalers using PyTorch Lightning\n",
    "\n",
    "This tutorial is identical to '2d_sd_super_resolution' but uses PyTorch Lightning (https://lightning.ai/docs/pytorch/stable/).\n",
    "\n",
    "Tutorial to illustrate the super-resolution task on medical images using Latent Diffusion Models (LDMs) [1]. For that, we will use an autoencoder to obtain a latent representation of the high-resolution images. Then, we train a diffusion model to infer this latent representation when conditioned on a low-resolution image.\n",
    "\n",
    "To improve the performance of our models, we will use a method called \"noise conditioning augmentation\" (introduced in [2] and used in Stable Diffusion v2.0 and Imagen Video [3]). During the training, we add noise to the low-resolution images using a random signal-to-noise ratio, and we condition the diffusion models on the amount of noise added. At sampling time, we use a fixed signal-to-noise ratio, representing a small amount of augmentation that aids in removing artefacts in the samples.\n",
    "\n",
    "\n",
    "[1] - Rombach et al. \"High-Resolution Image Synthesis with Latent Diffusion Models\" https://arxiv.org/abs/2112.10752\n",
    "\n",
    "[2] - Ho et al. \"Cascaded diffusion models for high fidelity image generation\" https://arxiv.org/abs/2106.15282\n",
    "\n",
    "[3] - Ho et al. \"High Definition Video Generation with Diffusion Models\" https://arxiv.org/abs/2210.02303"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b839bf2d",
   "metadata": {},
   "source": [
    "## Setup environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "77f7e633",
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm]\"\n",
    "!python -c \"import pytorch_lightning\" || pip install pytorch-lightning\n",
    "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "214066de",
   "metadata": {},
   "source": [
    "## Setup imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de71fe08",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import tempfile\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from monai import transforms\n",
    "from monai.apps import MedNISTDataset\n",
    "from monai.config import print_config\n",
    "from monai.data import CacheDataset, ThreadDataLoader\n",
    "from monai.utils import first, set_determinism\n",
    "from torch.amp import autocast\n",
    "from torch import nn\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "from monai.losses import PatchAdversarialLoss, PerceptualLoss\n",
    "from monai.networks.nets import AutoencoderKL, DiffusionModelUNet, PatchDiscriminator\n",
    "from monai.networks.schedulers import DDPMScheduler\n",
    "\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning.callbacks.model_checkpoint import ModelCheckpoint\n",
    "\n",
    "print_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0dde922",
   "metadata": {},
   "source": [
    "## Setup a data directory and download dataset\n",
    "Specify a MONAI_DATA_DIRECTORY variable, where the data will be downloaded. If not specified a temporary directory will be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ded618a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/tmpkazhiy23\n"
     ]
    }
   ],
   "source": [
    "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n",
    "root_dir = tempfile.mkdtemp() if directory is None else directory\n",
    "print(root_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e855e2b7-7e46-44d9-a567-3e91b5db2b6f",
   "metadata": {},
   "source": [
    "## Set deterministic training for reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9f0a17bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for reproducibility purposes set a seed\n",
    "set_determinism(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa76151c-0a37-471e-8312-10c2afcf11bc",
   "metadata": {},
   "source": [
    "## Description of data and download the training set\n",
    "\n",
    "For this tutorial, we use the head CT dataset from MedNIST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "298d964a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "MedNIST.tar.gz: 59.0MB [00:01, 38.7MB/s]                                                                                                                                                                                                                                                                   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-09-24 08:29:18,175 - INFO - Downloaded: /tmp/tmpkazhiy23/MedNIST.tar.gz\n",
      "2024-09-24 08:29:18,286 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
      "2024-09-24 08:29:18,286 - INFO - Writing into directory: /tmp/tmpkazhiy23.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:16<00:00, 2894.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-09-24 08:29:39,365 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n",
      "2024-09-24 08:29:39,365 - INFO - File exists: /tmp/tmpkazhiy23/MedNIST.tar.gz, skipped downloading.\n",
      "2024-09-24 08:29:39,366 - INFO - Non-empty folder exists in /tmp/tmpkazhiy23/MedNIST, skipped extracting.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:01<00:00, 3004.12it/s]\n"
     ]
    }
   ],
   "source": [
    "train_data = MedNISTDataset(root_dir=root_dir, section=\"training\", download=True, seed=0)\n",
    "train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n",
    "val_data = MedNISTDataset(root_dir=root_dir, section=\"validation\", download=True, seed=0)\n",
    "val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"HeadCT\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46bafb78",
   "metadata": {},
   "source": [
    "### Setup utils functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4f8eff03",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_transforms():\n",
    "    image_size = 64\n",
    "    train_transforms = transforms.Compose(\n",
    "        [\n",
    "            transforms.LoadImaged(keys=[\"image\"]),\n",
    "            transforms.EnsureChannelFirstd(keys=[\"image\"]),\n",
    "            transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),\n",
    "            transforms.RandAffined(\n",
    "                keys=[\"image\"],\n",
    "                rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],\n",
    "                translate_range=[(-1, 1), (-1, 1)],\n",
    "                scale_range=[(-0.05, 0.05), (-0.05, 0.05)],\n",
    "                spatial_size=[image_size, image_size],\n",
    "                padding_mode=\"zeros\",\n",
    "                prob=0.5,\n",
    "            ),\n",
    "            transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n",
    "            transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n",
    "        ]\n",
    "    )\n",
    "    return train_transforms\n",
    "\n",
    "\n",
    "def get_val_transforms():\n",
    "    val_transforms = transforms.Compose(\n",
    "        [\n",
    "            transforms.LoadImaged(keys=[\"image\"]),\n",
    "            transforms.EnsureChannelFirstd(keys=[\"image\"]),\n",
    "            transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True),\n",
    "            transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n",
    "            transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n",
    "        ]\n",
    "    )\n",
    "    return val_transforms\n",
    "\n",
    "\n",
    "def get_datasets():\n",
    "    train_transforms = get_train_transforms()\n",
    "    val_transforms = get_val_transforms()\n",
    "    train_ds = CacheDataset(data=train_datalist[:320], transform=train_transforms)\n",
    "    val_ds = CacheDataset(data=val_datalist[:32], transform=val_transforms)\n",
    "    return train_ds, val_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d80e045b",
   "metadata": {},
   "source": [
    "## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc)\n",
    "The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5d1caff",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AutoEncoder(pl.LightningModule):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.data_dir = root_dir\n",
    "        self.autoencoderkl = AutoencoderKL(\n",
    "            spatial_dims=2,\n",
    "            in_channels=1,\n",
    "            out_channels=1,\n",
    "            channels=(256, 512, 512),\n",
    "            latent_channels=3,\n",
    "            num_res_blocks=2,\n",
    "            norm_num_groups=32,\n",
    "            attention_levels=(False, False, True),\n",
    "        )\n",
    "        self.discriminator = PatchDiscriminator(spatial_dims=2, in_channels=1, num_layers_d=3, channels=64)\n",
    "        self.perceptual_loss = PerceptualLoss(spatial_dims=2, network_type=\"alex\")\n",
    "        self.perceptual_weight = 0.002\n",
    "        self.autoencoder_warm_up_n_epochs = 10\n",
    "        self.automatic_optimization = False\n",
    "        self.adv_loss = PatchAdversarialLoss(criterion=\"least_squares\")\n",
    "        self.adv_weight = 0.005\n",
    "        self.kl_weight = 1e-6\n",
    "\n",
    "    def forward(self, z):\n",
    "        return self.autoencoderkl(z)\n",
    "\n",
    "    def prepare_data(self):\n",
    "        self.train_ds, self.val_ds = get_datasets()\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True)\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4)\n",
    "\n",
    "    def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma):\n",
    "        recons_loss = F.l1_loss(reconstruction.float(), images.float())\n",
    "        p_loss = self.perceptual_loss(reconstruction.float(), images.float())\n",
    "        kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3])\n",
    "        kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]\n",
    "        loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss)\n",
    "        return loss_g, recons_loss\n",
    "\n",
    "    def _compute_loss_discriminator(self, images, reconstruction):\n",
    "        logits_fake = self.discriminator(reconstruction.contiguous().detach())[-1]\n",
    "        loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True)\n",
    "        logits_real = self.discriminator(images.contiguous().detach())[-1]\n",
    "        loss_d_real = self.adv_loss(logits_real, target_is_real=True, for_discriminator=True)\n",
    "        discriminator_loss = (loss_d_fake + loss_d_real) * 0.5\n",
    "        loss_d = self.adv_weight * discriminator_loss\n",
    "        return loss_d, discriminator_loss\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        optimizer_g, optimizer_d = self.optimizers()\n",
    "        images = batch[\"image\"]\n",
    "        reconstruction, z_mu, z_sigma = self.forward(images)\n",
    "        loss_g, recons_loss = self._compute_loss_generator(images, reconstruction, z_mu, z_sigma)\n",
    "        self.log(\"recons_loss\", recons_loss, batch_size=16, prog_bar=True)\n",
    "\n",
    "        if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n",
    "            logits_fake = self.discriminator(reconstruction.contiguous().float())[-1]\n",
    "            generator_loss = self.adv_loss(logits_fake, target_is_real=True, for_discriminator=False)\n",
    "            loss_g += self.adv_weight * generator_loss\n",
    "            self.log(\"gen_loss\", generator_loss, batch_size=16, prog_bar=True)\n",
    "\n",
    "        self.log(\"loss_g\", loss_g, batch_size=16, prog_bar=True)\n",
    "        self.manual_backward(loss_g)\n",
    "        optimizer_g.step()\n",
    "        optimizer_g.zero_grad()\n",
    "        self.untoggle_optimizer(optimizer_g)\n",
    "\n",
    "        if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n",
    "            loss_d, discriminator_loss = self._compute_loss_discriminator(images, reconstruction)\n",
    "            self.log(\"disc_loss\", loss_d, batch_size=16, prog_bar=True)\n",
    "            self.log(\"train_loss_d\", loss_d, batch_size=16, prog_bar=True)\n",
    "            self.manual_backward(loss_d)\n",
    "            optimizer_d.step()\n",
    "            optimizer_d.zero_grad()\n",
    "            self.untoggle_optimizer(optimizer_d)\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        images = batch[\"image\"]\n",
    "        reconstruction, z_mu, z_sigma = self.autoencoderkl(images)\n",
    "        recons_loss = F.l1_loss(images.float(), reconstruction.float())\n",
    "        self.log(\"val_loss_d\", recons_loss, batch_size=1, prog_bar=True)\n",
    "        self.images = images\n",
    "        self.reconstruction = reconstruction\n",
    "\n",
    "    def on_validation_epoch_end(self):\n",
    "        # ploting reconstruction\n",
    "        plt.figure(figsize=(2, 2))\n",
    "        plt.imshow(\n",
    "            torch.cat([self.images[0, 0].cpu(), self.reconstruction[0, 0].cpu()], dim=1), vmin=0, vmax=1, cmap=\"gray\"\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.axis(\"off\")\n",
    "        plt.show()\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5)\n",
    "        optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=1e-4)\n",
    "        return [optimizer_g, optimizer_d], []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c16de505",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "## Train Autoencoder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e740cb2d-5a57-42ed-806b-e8c720a6f922",
   "metadata": {},
   "source": [
    "In this section, we train a spatial autoencoder to learn how to compress high-resolution images into a latent space representation. We need to ensure that the latent space spatial shape matches that of the low resolution images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9d903aaa",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
      "  warnings.warn(\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
      "  warnings.warn(msg)\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/lpips/lpips.py:107: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  self.load_state_dict(torch.load(model_path, map_location='cpu'), strict=False)\n",
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n",
      "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 1478.97it/s]\n",
      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 773.46it/s]\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:654: Checkpoint directory /tmp/tmpkazhiy23 exists and is not empty.\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name            | Type                 | Params | Mode \n",
      "-----------------------------------------------------------------\n",
      "0 | autoencoderkl   | AutoencoderKL        | 75.1 M | train\n",
      "1 | discriminator   | PatchDiscriminator   | 2.8 M  | train\n",
      "2 | perceptual_loss | PerceptualLoss       | 2.5 M  | train\n",
      "3 | adv_loss        | PatchAdversarialLoss | 0      | train\n",
      "-----------------------------------------------------------------\n",
      "77.8 M    Trainable params\n",
      "2.5 M     Non-trainable params\n",
      "80.3 M    Total params\n",
      "321.225   Total estimated model params size (MB)\n",
      "251       Modules in train mode\n",
      "41        Modules in eval mode\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e3c00d0cf81e4f5484624e5e3278d6bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: |                                                                                                   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=75` reached.\n"
     ]
    }
   ],
   "source": [
    "max_epochs = 75\n",
    "val_interval = 10\n",
    "\n",
    "\n",
    "# initialise the LightningModule\n",
    "ae_net = AutoEncoder()\n",
    "\n",
    "# set up checkpoints\n",
    "\n",
    "checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename=\"best_metric_model\")\n",
    "\n",
    "\n",
    "# initialise Lightning's trainer.\n",
    "trainer = pl.Trainer(\n",
    "    devices=1,\n",
    "    max_epochs=max_epochs,\n",
    "    check_val_every_n_epoch=val_interval,\n",
    "    num_sanity_val_steps=0,\n",
    "    callbacks=checkpoint_callback,\n",
    "    default_root_dir=root_dir,\n",
    ")\n",
    "\n",
    "# train\n",
    "trainer.fit(ae_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7108b87",
   "metadata": {},
   "source": [
    "## Rescaling factor\n",
    "\n",
    "As mentioned in Rombach et al. [1] Section 4.3.2 and D.1, the signal-to-noise ratio (induced by the scale of the latent space) became crucial in image-to-image translation models (such as the ones used for super-resolution). For this reason, we will compute the component-wise standard deviation to be used as scaling factor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ccb6ba9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scaling factor set to 0.6885251998901367\n"
     ]
    }
   ],
   "source": [
    "def get_scale_factor():\n",
    "    ae_net.eval()\n",
    "    device = torch.device(\"cuda:0\")\n",
    "    ae_net.to(device)\n",
    "\n",
    "    train_loader = ae_net.train_dataloader()\n",
    "    check_data = first(train_loader)\n",
    "    z = ae_net.autoencoderkl.encode_stage_2_inputs(check_data[\"image\"].to(ae_net.device))\n",
    "    print(f\"Scaling factor set to {1/torch.std(z)}\")\n",
    "    scale_factor = 1 / torch.std(z)\n",
    "    return scale_factor\n",
    "\n",
    "\n",
    "scale_factor = get_scale_factor()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3baa2b0f",
   "metadata": {},
   "source": [
    "## Define the LightningModule for DiffusionModelUnet (transforms, network, loaders, etc)\n",
    "\n",
    "The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "731034ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DiffusionUNET(pl.LightningModule):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.data_dir = root_dir\n",
    "        self.unet = DiffusionModelUNet(\n",
    "            spatial_dims=2,\n",
    "            in_channels=4,\n",
    "            out_channels=3,\n",
    "            num_res_blocks=2,\n",
    "            channels=(256, 256, 512, 1024),\n",
    "            attention_levels=(False, False, True, True),\n",
    "            num_head_channels=(0, 0, 64, 64),\n",
    "        )\n",
    "        self.max_noise_level = 350\n",
    "        self.scheduler = DDPMScheduler(\n",
    "            num_train_timesteps=1000, schedule=\"linear_beta\", beta_start=0.0015, beta_end=0.0195\n",
    "        )\n",
    "        self.z = ae_net.autoencoderkl.eval()\n",
    "\n",
    "    def forward(self, x, timesteps, low_res_timesteps):\n",
    "        return self.unet(x=x, timesteps=timesteps, class_labels=low_res_timesteps)\n",
    "\n",
    "    def prepare_data(self):\n",
    "        self.train_ds, self.val_ds = get_datasets()\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True)\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4)\n",
    "\n",
    "    def _calculate_loss(self, batch, batch_idx, plt_image=False):\n",
    "        images = batch[\"image\"]\n",
    "        low_res_image = batch[\"low_res_image\"]\n",
    "        with autocast(\"cuda\", enabled=True):\n",
    "            with torch.no_grad():\n",
    "                latent = self.z.encode_stage_2_inputs(images) * scale_factor\n",
    "\n",
    "            # Noise augmentation\n",
    "            noise = torch.randn_like(latent)\n",
    "            low_res_noise = torch.randn_like(low_res_image)\n",
    "            timesteps = torch.randint(\n",
    "                0, self.scheduler.num_train_timesteps, (latent.shape[0],), device=latent.device\n",
    "            ).long()\n",
    "            low_res_timesteps = torch.randint(\n",
    "                0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device\n",
    "            ).long()\n",
    "\n",
    "            noisy_latent = self.scheduler.add_noise(original_samples=latent, noise=noise, timesteps=timesteps)\n",
    "            noisy_low_res_image = self.scheduler.add_noise(\n",
    "                original_samples=low_res_image, noise=low_res_noise, timesteps=low_res_timesteps\n",
    "            )\n",
    "\n",
    "            latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1)\n",
    "\n",
    "            noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps)\n",
    "            loss = F.mse_loss(noise_pred.float(), noise.float())\n",
    "\n",
    "        if plt_image:\n",
    "            # Sampling image during training\n",
    "            sampling_image = low_res_image[0].unsqueeze(0)\n",
    "            latents = torch.randn((1, 3, 16, 16)).to(sampling_image.device)\n",
    "            low_res_noise = torch.randn((1, 1, 16, 16)).to(sampling_image.device)\n",
    "            noise_level = 20\n",
    "            noise_level = torch.Tensor((noise_level,)).long().to(sampling_image.device)\n",
    "\n",
    "            noisy_low_res_image = self.scheduler.add_noise(\n",
    "                original_samples=sampling_image,\n",
    "                noise=low_res_noise,\n",
    "                timesteps=noise_level,\n",
    "            )\n",
    "            self.scheduler.set_timesteps(num_inference_steps=1000)\n",
    "            for t in tqdm(self.scheduler.timesteps, ncols=110):\n",
    "                with autocast(\"cuda\", enabled=True):\n",
    "                    with torch.no_grad():\n",
    "                        latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1)\n",
    "                        noise_pred = self.forward(\n",
    "                            latent_model_input, torch.Tensor((t,)).to(sampling_image.device), noise_level\n",
    "                        )\n",
    "                    latents, _ = self.scheduler.step(noise_pred, t, latents)\n",
    "            with torch.no_grad():\n",
    "                decoded = self.z.decode_stage_2_outputs(latents / scale_factor)\n",
    "            low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n",
    "            # plot images\n",
    "\n",
    "            self.images = images\n",
    "            self.low_res_bicubic = low_res_bicubic\n",
    "            self.decoded = decoded\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _plot_image(self, images, low_res_bicubic, decoded):\n",
    "        plt.figure(figsize=(2, 2))\n",
    "        plt.style.use(\"default\")\n",
    "        plt.imshow(\n",
    "            torch.cat([images[0, 0].cpu(), low_res_bicubic[0, 0].cpu(), decoded[0, 0].cpu()], dim=1),\n",
    "            vmin=0,\n",
    "            vmax=1,\n",
    "            cmap=\"gray\",\n",
    "        )\n",
    "        plt.tight_layout()\n",
    "        plt.axis(\"off\")\n",
    "        plt.show()\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        loss = self._calculate_loss(batch, batch_idx)\n",
    "        self.log(\"train_loss\", loss, batch_size=16, prog_bar=True)\n",
    "        return loss\n",
    "\n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        loss = self._calculate_loss(batch, batch_idx, plt_image=True)\n",
    "        self.log(\"val_loss\", loss, batch_size=16, prog_bar=True)\n",
    "        return loss\n",
    "\n",
    "    def on_validation_epoch_end(self):\n",
    "        self._plot_image(self.images, self.low_res_bicubic, self.decoded)\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.unet.parameters(), lr=5e-5)\n",
    "        return optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b386a0c2",
   "metadata": {},
   "source": [
    "## Train Diffusion Model\n",
    "\n",
    "In order to train the diffusion model to perform super-resolution, we will need to **concatenate the latent representation of the high-resolution with the low-resolution image**. Therefore, the number of input channels to the diffusion model will be the sum of the number of channels in the low-resolution (1) and the number of channels of the high-resolution image latent representation (3). In this case,  we create a Diffusion model with `in_channels=4`. Since only the output latent representation is interesting, we set `out_channels=3`. \n",
    "\n",
    "**At inference time** we do not have a high-resolution image. Instead, we pass the concatenation of the low resolution image, and noise of the same shape as the latent space representation.\n",
    "\n",
    "As mentioned, we will use the conditioned augmentation (introduced in [2] section 3 and used on Stable Diffusion Upscalers and Imagen Video [3] Section 2.5) as it has been shown critical for cascaded diffusion models, as well for super-resolution tasks. For this, we apply Gaussian noise augmentation to the low-resolution images. We will use a scheduler low_res_scheduler to add this noise, with the t step defining the signal-to-noise ratio and use the t value to condition the diffusion model (inputted using class_labels argument)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "936bbb9c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n",
      "\n",
      "Loading dataset:   0%|                                                                                                                                                                                                                                                             | 0/320 [00:00<?, ?it/s]\u001b[A\n",
      "Loading dataset:  46%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████▉                                                                                                                                   | 146/320 [00:00<00:00, 1450.29it/s]\u001b[A\n",
      "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 1451.62it/s]\u001b[A\n",
      "\n",
      "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 784.55it/s]\u001b[A\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:654: Checkpoint directory /tmp/tmpkazhiy23 exists and is not empty.\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name      | Type               | Params | Mode \n",
      "---------------------------------------------------------\n",
      "0 | unet      | DiffusionModelUNet | 266 M  | train\n",
      "1 | scheduler | DDPMScheduler      | 0      | train\n",
      "2 | z         | AutoencoderKL      | 75.1 M | eval \n",
      "---------------------------------------------------------\n",
      "342 M     Trainable params\n",
      "0         Non-trainable params\n",
      "342 M     Total params\n",
      "1,368.189 Total estimated model params size (MB)\n",
      "390       Modules in train mode\n",
      "221       Modules in eval mode\n",
      "/home/vf19/PycharmProjects/MONAI_tutorials/venv/lib/python3.10/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "040495b845ac4e9d8fbccbe945e0c157",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training: |                                                                                                   …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7b0fe8bcefb7417582b28aa4ad528022",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7f8d42b0e1404719a2a7ebaf64599229",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "17aa3327b5084a8f96c140125efd91e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b436bd5b88b541aa8fe7eb66d17846cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fa63aaeaed78402f8f478a467bb73cd5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "556b1b9b42d74eb0923539ee559e06d9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Validation: |                                                                                                 …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66c3255d7df7478e9277de2e512ec1d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "629c905cf1f749b8a596c4b00bae7f5b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 200x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=200` reached.\n"
     ]
    }
   ],
   "source": [
    "max_epochs = 200\n",
    "val_interval = 50\n",
    "\n",
    "\n",
    "# initialise the LightningModule\n",
    "d_net = DiffusionUNET()\n",
    "\n",
    "# set up checkpoints\n",
    "\n",
    "checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename=\"best_metric_model_dunet\")\n",
    "\n",
    "\n",
    "# initialise Lightning's trainer.\n",
    "trainer = pl.Trainer(\n",
    "    devices=1,\n",
    "    max_epochs=max_epochs,\n",
    "    check_val_every_n_epoch=val_interval,\n",
    "    num_sanity_val_steps=0,\n",
    "    callbacks=checkpoint_callback,\n",
    "    default_root_dir=root_dir,\n",
    ")\n",
    "\n",
    "# train\n",
    "trainer.fit(d_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30f24595",
   "metadata": {},
   "source": [
    "### Plotting sampling example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19ba049e-fca6-4c76-b7b1-7e992d370583",
   "metadata": {},
   "source": [
    "As mentioned above, at inference time, we only need to pass noise of the same shape of the latent concatenated to the low-resolution image, to get the latent representation of the corresponding high-resolution image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "155be091",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "837b6b2a5e1f42ab862c9cf589dbb615",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|                                                                                | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_samples = 3\n",
    "\n",
    "\n",
    "def get_images_to_plot():\n",
    "    d_net.eval()\n",
    "    device = torch.device(\"cuda:0\")\n",
    "    d_net.to(device)\n",
    "\n",
    "    val_loader = d_net.val_dataloader()\n",
    "    check_data = first(val_loader)\n",
    "    images = check_data[\"image\"].to(d_net.device)\n",
    "\n",
    "    sampling_image = check_data[\"low_res_image\"][:num_samples].to(d_net.device)\n",
    "    latents = torch.randn((num_samples, 3, 16, 16)).to(d_net.device)\n",
    "    low_res_noise = torch.randn((num_samples, 1, 16, 16)).to(d_net.device)\n",
    "    noise_level = 10\n",
    "    noise_level = torch.Tensor((noise_level,)).long().to(d_net.device)\n",
    "    scheduler = d_net.scheduler\n",
    "    noisy_low_res_image = scheduler.add_noise(\n",
    "        original_samples=sampling_image, noise=low_res_noise, timesteps=torch.Tensor((noise_level,)).long()\n",
    "    )\n",
    "\n",
    "    scheduler.set_timesteps(num_inference_steps=1000)\n",
    "    for t in tqdm(scheduler.timesteps, ncols=110):\n",
    "        with autocast(\"cuda\", enabled=True):\n",
    "            with torch.no_grad():\n",
    "                latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1)\n",
    "                noise_pred = d_net.forward(\n",
    "                    x=latent_model_input, timesteps=torch.Tensor((t,)).to(d_net.device), low_res_timesteps=noise_level\n",
    "                )\n",
    "            # 2. compute previous image: x_t -> x_t-1\n",
    "            latents, _ = scheduler.step(noise_pred, t, latents)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor)\n",
    "    return sampling_image, images, decoded\n",
    "\n",
    "\n",
    "sampling_image, images, decoded = get_images_to_plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "32e16e69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n",
    "fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8))\n",
    "axs[0, 0].set_title(\"Original image\")\n",
    "axs[0, 1].set_title(\"Low-resolution Image\")\n",
    "axs[0, 2].set_title(\"Outputted image\")\n",
    "for i in range(0, num_samples):\n",
    "    axs[i, 0].imshow(images[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n",
    "    axs[i, 0].axis(\"off\")\n",
    "    axs[i, 1].imshow(low_res_bicubic[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n",
    "    axs[i, 1].axis(\"off\")\n",
    "    axs[i, 2].imshow(decoded[i, 0].cpu().detach().numpy(), vmin=0, vmax=1, cmap=\"gray\")\n",
    "    axs[i, 2].axis(\"off\")\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa52acc",
   "metadata": {},
   "source": [
    "### Clean-up data directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3a6f6d5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "if directory is None:\n",
    "    shutil.rmtree(root_dir)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "formats": "ipynb,py:percent"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
